home *** CD-ROM | disk | FTP | other *** search
/ The Programmer Disk / The Programmer Disk (Microforum).iso / xpro / c / pro22 / cbcmp.c < prev    next >
Text File  |  1990-06-20  |  9KB  |  503 lines
  1. /*    Copyright (c) 1989 Citadel    */
  2. /*       All Rights Reserved        */
  3.  
  4. /* #ident    "@(#)cbcmp.c    1.4 - 90/06/20" */
  5.  
  6. /* ansi headers */
  7. #include <ctype.h>
  8. #include <errno.h>
  9. /*#include <stddef.h>*/
  10. /*#include <string.h>*/
  11.  
  12. /* library headers */
  13. #include <blkio.h>
  14.  
  15. /* local headers */
  16. #include "cbase_.h"
  17.  
  18. /*man---------------------------------------------------------------------------
  19. NAME
  20.      cbcmp - cbase comparison functions
  21.  
  22. SYNOPSIS
  23.  
  24. DESCRIPTION
  25.  
  26. SEE ALSO
  27.      cbexp, cbimp.
  28.  
  29. ------------------------------------------------------------------------------*/
  30. #define vcmp(CMPFCT) {                            \
  31.     int i = 0;                            \
  32.     int c = 0;                            \
  33.     int nelems = n / sizeof(*cp1);                    \
  34.                                     \
  35.     for (i = 0; i < nelems; ++i) {                    \
  36.         c = CMPFCT(cp1, cp2, sizeof(*cp1));            \
  37.         if (c != 0) return c;                    \
  38.         ++cp1;                            \
  39.         ++cp2;                            \
  40.     }                                \
  41.     return 0;                            \
  42. }
  43.  
  44. /* charcmp:  t_char comparison function */
  45. static int charcmp(p1, p2, n)
  46. const void *p1;
  47. const void *p2;
  48. size_t n;
  49. {
  50.     signed char n1 = '\0';
  51.     signed char n2 = '\0';
  52.  
  53.     memcpy(&n1, p1, sizeof(n1));
  54.     memcpy(&n2, p2, sizeof(n2));
  55.     if (n1 < n2) {
  56.         return -1;
  57.     } else if (n1 > n2) {
  58.         return 1;
  59.     }
  60.  
  61.     return 0;
  62. }
  63.  
  64. /* charvcmp:  t_charv comparison function */
  65. static int charvcmp(p1, p2, n)
  66. const void *p1;
  67. const void *p2;
  68. size_t n;
  69. {
  70.     signed char *cp1 = (signed char *)p1;
  71.     signed char *cp2 = (signed char *)p2;
  72.  
  73.     vcmp(charcmp);
  74. }
  75.  
  76. /* ucharcmp:  t_uchar comparison function */
  77. static int ucharcmp(p1, p2, n)
  78. const void *p1;
  79. const void *p2;
  80. size_t n;
  81. {
  82.     unsigned char n1 = '\0';
  83.     unsigned char n2 = '\0';
  84.  
  85.     memcpy(&n1, p1, sizeof(n1));
  86.     memcpy(&n2, p2, sizeof(n2));
  87.     if (n1 < n2) {
  88.         return -1;
  89.     } else if (n1 > n2) {
  90.         return 1;
  91.     }
  92.  
  93.     return 0;
  94. }
  95.  
  96. /* ucharvcmp:  t_ucharv comparison function */
  97. static int ucharvcmp(p1, p2, n)
  98. const void *p1;
  99. const void *p2;
  100. size_t n;
  101. {
  102.     unsigned char *cp1 = (unsigned char *)p1;
  103.     unsigned char *cp2 = (unsigned char *)p2;
  104.  
  105.     vcmp(ucharcmp);
  106. }
  107.  
  108. /* shortcmp:  t_short comparison function */
  109. static int shortcmp(p1, p2, n)
  110. const void *p1;
  111. const void *p2;
  112. size_t n;
  113. {
  114.     signed short n1 = 0;
  115.     signed short n2 = 0;
  116.  
  117.     memcpy(&n1, p1, sizeof(n1));
  118.     memcpy(&n2, p2, sizeof(n2));
  119.     if (n1 < n2) {
  120.         return -1;
  121.     } else if (n1 > n2) {
  122.         return 1;
  123.     }
  124.  
  125.     return 0;
  126. }
  127.  
  128. /* shortvcmp:  t_shortv comparison function */
  129. static int shortvcmp(p1, p2, n)
  130. const void *p1;
  131. const void *p2;
  132. size_t n;
  133. {
  134.     signed short *cp1 = (signed short *)p1;
  135.     signed short *cp2 = (signed short *)p2;
  136.  
  137.     vcmp(shortcmp);
  138. }
  139.  
  140. /* ushortcmp:  t_ushort comparison function */
  141. static int ushortcmp(p1, p2, n)
  142. const void *p1;
  143. const void *p2;
  144. size_t n;
  145. {
  146.     unsigned short n1 = 0;
  147.     unsigned short n2 = 0;
  148.  
  149.     memcpy(&n1, p1, sizeof(n1));
  150.     memcpy(&n2, p2, sizeof(n2));
  151.     if (n1 < n2) {
  152.         return -1;
  153.     } else if (n1 > n2) {
  154.         return 1;
  155.     }
  156.  
  157.     return 0;
  158. }
  159.  
  160. /* ushortvcmp:  t_ushortv comparison function */
  161. static int ushortvcmp(p1, p2, n)
  162. const void *p1;
  163. const void *p2;
  164. size_t n;
  165. {
  166.     unsigned short *cp1 = (unsigned short *)p1;
  167.     unsigned short *cp2 = (unsigned short *)p2;
  168.  
  169.     vcmp(ushortcmp);
  170. }
  171.  
  172. /* intcmp:  t_int comparison function */
  173. static int intcmp(p1, p2, n)
  174. const void *p1;
  175. const void *p2;
  176. size_t n;
  177. {
  178.     signed int n1 = 0;
  179.     signed int n2 = 0;
  180.  
  181.     memcpy(&n1, p1, sizeof(n1));
  182.     memcpy(&n2, p2, sizeof(n2));
  183.     if (n1 < n2) {
  184.         return -1;
  185.     } else if (n1 > n2) {
  186.         return 1;
  187.     }
  188.  
  189.     return 0;
  190. }
  191.  
  192. /* intvcmp:  t_intv comparison function */
  193. static int intvcmp(p1, p2, n)
  194. const void *p1;
  195. const void *p2;
  196. size_t n;
  197. {
  198.     signed int *cp1 = (signed int *)p1;
  199.     signed int *cp2 = (signed int *)p2;
  200.  
  201.     vcmp(intcmp);
  202. }
  203.  
  204. /* uintcmp:  t_uint comparison function */
  205. static int uintcmp(p1, p2, n)
  206. const void *p1;
  207. const void *p2;
  208. size_t n;
  209. {
  210.     unsigned int n1 = 0;
  211.     unsigned int n2 = 0;
  212.  
  213.     memcpy(&n1, p1, sizeof(n1));
  214.     memcpy(&n2, p2, sizeof(n2));
  215.     if (n1 < n2) {
  216.         return -1;
  217.     } else if (n1 > n2) {
  218.         return 1;
  219.     }
  220.  
  221.     return 0;
  222. }
  223.  
  224. /* uintvcmp:  t_uintv comparison function */
  225. static int uintvcmp(p1, p2, n)
  226. const void *p1;
  227. const void *p2;
  228. size_t n;
  229. {
  230.     unsigned int *cp1 = (unsigned int *)p1;
  231.     unsigned int *cp2 = (unsigned int *)p2;
  232.  
  233.     vcmp(uintcmp);
  234. }
  235.  
  236. /* longcmp:  t_long comparison function */
  237. static int longcmp(p1, p2, n)
  238. const void *p1;
  239. const void *p2;
  240. size_t n;
  241. {
  242.     signed long n1 = 0;
  243.     signed long n2 = 0;
  244.  
  245.     memcpy(&n1, p1, sizeof(n1));
  246.     memcpy(&n2, p2, sizeof(n2));
  247.     if (n1 < n2) {
  248.         return -1;
  249.     } else if (n1 > n2) {
  250.         return 1;
  251.     }
  252.  
  253.     return 0;
  254. }
  255.  
  256. /* longvcmp:  t_longv comparison function */
  257. static int longvcmp(p1, p2, n)
  258. const void *p1;
  259. const void *p2;
  260. size_t n;
  261. {
  262.     signed long *cp1 = (signed long *)p1;
  263.     signed long *cp2 = (signed long *)p2;
  264.  
  265.     vcmp(longcmp);
  266. }
  267.  
  268. /* ulongcmp:  t_ulong comparison function */
  269. static int ulongcmp(p1, p2, n)
  270. const void *p1;
  271. const void *p2;
  272. size_t n;
  273. {
  274.     unsigned long n1 = 0;
  275.     unsigned long n2 = 0;
  276.  
  277.     memcpy(&n1, p1, sizeof(n1));
  278.     memcpy(&n2, p2, sizeof(n2));
  279.     if (n1 < n2) {
  280.         return -1;
  281.     } else if (n1 > n2) {
  282.         return 1;
  283.     }
  284.  
  285.     return 0;
  286. }
  287.  
  288. /* ulongvcmp:  t_ulongv comparison function */
  289. static int ulongvcmp(p1, p2, n)
  290. const void *p1;
  291. const void *p2;
  292. size_t n;
  293. {
  294.     unsigned long *cp1 = (unsigned long *)p1;
  295.     unsigned long *cp2 = (unsigned long *)p2;
  296.  
  297.     vcmp(ulongcmp);
  298. }
  299.  
  300. /* floatcmp:  t_float comparison function */
  301. static int floatcmp(p1, p2, n)
  302. const void *p1;
  303. const void *p2;
  304. size_t n;
  305. {
  306.     float n1 = 0;
  307.     float n2 = 0;
  308.  
  309.     memcpy(&n1, p1, sizeof(n1));
  310.     memcpy(&n2, p2, sizeof(n2));
  311.     if (n1 < n2) {
  312.         return -1;
  313.     } else if (n1 > n2) {
  314.         return 1;
  315.     }
  316.  
  317.     return 0;
  318. }
  319.  
  320. /* floatvcmp:  t_floatv comparison function */
  321. static int floatvcmp(p1, p2, n)
  322. const void *p1;
  323. const void *p2;
  324. size_t n;
  325. {
  326.     float *cp1 = (float *)p1;
  327.     float *cp2 = (float *)p2;
  328.  
  329.     vcmp(floatcmp);
  330. }
  331.  
  332. /* dblcmp:  t_double comparison function */
  333. static int dblcmp(p1, p2, n)
  334. const void *p1;
  335. const void *p2;
  336. size_t n;
  337. {
  338.     double n1 = 0;
  339.     double n2 = 0;
  340.  
  341.     memcpy(&n1, p1, sizeof(n1));
  342.     memcpy(&n2, p2, sizeof(n2));
  343.     if (n1 < n2) {
  344.         return -1;
  345.     } else if (n1 > n2) {
  346.         return 1;
  347.     }
  348.  
  349.     return 0;
  350. }
  351.  
  352. /* dblvcmp:  t_doublev comparison function */
  353. static int dblvcmp(p1, p2, n)
  354. const void *p1;
  355. const void *p2;
  356. size_t n;
  357. {
  358.     double *cp1 = (double *)p1;
  359.     double *cp2 = (double *)p2;
  360.  
  361.     vcmp(dblcmp);
  362. }
  363.  
  364. /* ldblcmp:  t_ldouble comparison function */
  365. static int ldblcmp(p1, p2, n)
  366. const void *p1;
  367. const void *p2;
  368. size_t n;
  369. {
  370. #ifdef AC_LDOUBLE
  371.     long double n1 = 0;
  372.     long double n2 = 0;
  373.  
  374.     memcpy(&n1, p1, sizeof(n1));
  375.     memcpy(&n2, p2, sizeof(n2));
  376.     if (n1 < n2) {
  377.         return -1;
  378.     } else if (n1 > n2) {
  379.         return 1;
  380.     }
  381.  
  382.     return 0;
  383. #else
  384.     return 0;
  385. #endif
  386. }
  387.  
  388. /* ldblvcmp:  t_ldoublev comparison function */
  389. static int ldblvcmp(p1, p2, n)
  390. const void *p1;
  391. const void *p2;
  392. size_t n;
  393. {
  394. #ifdef AC_LDOUBLE
  395.     long double *cp1 = (long double *)p1;
  396.     long double *cp2 = (long double *)p2;
  397.  
  398.     vcmp(ldblcmp);
  399. #else
  400.     return 0;
  401. #endif
  402. }
  403.  
  404. /* ptrcmp:  t_pointer comparison function */
  405. static int ptrcmp(p1, p2, n)
  406. const void *p1;
  407. const void *p2;
  408. size_t n;
  409. {
  410.     void *n1 = NULL;
  411.     void *n2 = NULL;
  412.  
  413.     memcpy(&n1, p1, sizeof(n1));
  414.     memcpy(&n2, p2, sizeof(n2));
  415.     if (n1 < n2) {
  416.         return -1;
  417.     } else if (n1 > n2) {
  418.         return 1;
  419.     }
  420.  
  421.     return 0;
  422. }
  423.  
  424. /* ptrvcmp:  t_pointerv comparison function */
  425. static int ptrvcmp(p1, p2, n)
  426. const void *p1;
  427. const void *p2;
  428. size_t n;
  429. {
  430.     void **cp1 = (void **)p1;
  431.     void **cp2 = (void **)p2;
  432.  
  433.     vcmp(ptrcmp);
  434. }
  435.  
  436. /* t_string -> use standard library function strncmp */
  437.  
  438. /* cistrncmp:  t_cistring comparison function */
  439. static int cistrncmp(cs1, cs2, n)
  440. const char *cs1;
  441. const char *cs2;
  442. size_t n;
  443. {
  444.     int i = 0;    /* loop counter */
  445.  
  446.     for (i = 0; i < n && toupper(*cs1) == toupper(*cs2); ++i, ++cs1, ++cs2) {
  447.         if (*cs1 == '\0') {
  448.             return 0;
  449.         }
  450.     }
  451.  
  452.     return toupper(*cs1) - toupper(*cs2);
  453. }
  454.  
  455. /* bincmp:  t_binary comparison function */
  456. static int bincmp(p1, p2, n)
  457. const void *p1;
  458. const void *p2;
  459. size_t n;
  460. {
  461.     unsigned char *v1 = (unsigned char *)p1;
  462.     unsigned char *v2 = (unsigned char *)p2;
  463.  
  464.     for (; n > 0; --n, ++v1, ++v2) {
  465.         if (*v1 != *v2) {
  466.             return *v1 - *v2;
  467.         }
  468.     }
  469.  
  470.     return 0;
  471. }
  472.  
  473. /* cbase comparison function table definition */
  474. const cbcmp_t cbcmpv[] = {
  475.     charcmp,        /* t_char    =  0 */
  476.     charvcmp,        /* t_charv    =  1 */
  477.     ucharcmp,        /* t_uchar    =  2 */
  478.     ucharvcmp,        /* t_ucharv    =  3 */
  479.     shortcmp,        /* t_short    =  4 */
  480.     shortvcmp,        /* t_shortv    =  5 */
  481.     ushortcmp,        /* t_ushort    =  6 */
  482.     ushortvcmp,        /* t_ushortv    =  7 */
  483.     intcmp,            /* t_int    =  8 */
  484.     intvcmp,        /* t_intv    =  9 */
  485.     uintcmp,        /* t_uint    = 10 */
  486.     uintvcmp,        /* t_uintv    = 11 */
  487.     longcmp,        /* t_long    = 12 */
  488.     longvcmp,        /* t_longv    = 13 */
  489.     ulongcmp,        /* t_ulong    = 14 */
  490.     ulongvcmp,        /* t_ulongv    = 15 */
  491.     floatcmp,        /* t_float    = 16 */
  492.     floatvcmp,        /* t_floatv    = 17 */
  493.     dblcmp,            /* t_double    = 18 */
  494.     dblvcmp,        /* t_doublev    = 19 */
  495.     ldblcmp,        /* t_ldouble    = 20 */
  496.     ldblvcmp,        /* t_ldoublev    = 21 */
  497.     ptrcmp,            /* t_pointer    = 22 */
  498.     ptrvcmp,        /* t_pointerv    = 23 */
  499.     (cbcmp_t)strncmp,    /* t_string    = 24 */
  500.     (cbcmp_t)cistrncmp,    /* t_cistring    = 25 */
  501.     bincmp            /* t_binary    = 26 */
  502. };
  503.